package com.xiaoxiaoniu.airoleplay.config;

import com.xiaoxiaoniu.airoleplay.model.Conversation;
import com.xiaoxiaoniu.airoleplay.model.Message;
import com.xiaoxiaoniu.airoleplay.repository.ConversationRepository;
import com.xiaoxiaoniu.airoleplay.repository.MessageRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.List;

/**
 * 定时任务配置类
 * 实现会话清理等周期性任务
 */
@Configuration
@EnableScheduling
public class ScheduledTasksConfig {

    private static final Logger logger = LoggerFactory.getLogger(ScheduledTasksConfig.class);

    @Autowired
    private ConversationRepository conversationRepository;

    @Autowired
    private MessageRepository messageRepository;

    /**
     * 定期清理过期会话和相关消息
     * 每天凌晨2点执行一次
     * 默认保留最近30天的会话
     */
    @Scheduled(cron = "0 0 2 * * ?")
    public void cleanupExpiredConversations() {
        logger.info("开始执行会话清理任务");

        // 计算30天前的时间
        LocalDateTime thirtyDaysAgo = LocalDateTime.now().minus(30, ChronoUnit.DAYS);
        
        // 获取所有超过30天没有更新的会话
        List<Conversation> expiredConversations = conversationRepository.findExpiredConversations(thirtyDaysAgo);
        
        if (expiredConversations.isEmpty()) {
            logger.info("没有找到需要清理的过期会话");
            return;
        }
        
        int conversationCount = expiredConversations.size();
        logger.info("找到 {} 个需要清理的过期会话", conversationCount);
        
        // 清理每个过期会话的消息和会话本身
        for (Conversation conversation : expiredConversations) {
            String conversationId = conversation.getConversationId();
            
            // 先删除该会话的所有消息
            List<Message> messages = messageRepository.findByConversationIdOrderByTimestampAsc(conversationId);
            if (!messages.isEmpty()) {
                messageRepository.deleteAll(messages);
                logger.info("删除了会话 {} 的 {} 条消息", conversationId, messages.size());
            }
            
            // 再删除会话本身
            conversationRepository.delete(conversation);
            logger.info("删除了过期会话: {}, 角色: {}", conversationId, conversation.getRoleName());
        }
        
        logger.info("会话清理任务执行完成，共清理了 {} 个会话", conversationCount);
    }

    /**
     * 清理孤立的消息（没有关联会话的消息）
     * 每周日凌晨3点执行一次
     */
    @Scheduled(cron = "0 0 3 ? * SUN")
    public void cleanupOrphanMessages() {
        logger.info("开始执行孤立消息清理任务");
        
        // 获取所有会话ID
        List<String> allConversationIds = conversationRepository.findAllConversationIds();
        
        // 获取所有没有关联会话的消息
        List<Message> orphanMessages = messageRepository.findOrphanMessages(allConversationIds);
        
        if (orphanMessages.isEmpty()) {
            logger.info("没有找到需要清理的孤立消息");
            return;
        }
        
        int messageCount = orphanMessages.size();
        messageRepository.deleteAll(orphanMessages);
        
        logger.info("孤立消息清理任务执行完成，共清理了 {} 条消息", messageCount);
    }

    /**
     * 会话统计报告
     * 每月1号凌晨4点执行一次
     */
    @Scheduled(cron = "0 0 4 1 * ?")
    public void generateConversationReport() {
        logger.info("开始生成会话统计报告");
        
        // 统计总会话数
        long totalConversations = conversationRepository.count();
        
        // 统计总消息数
        long totalMessages = messageRepository.count();
        
        // 计算平均每个会话的消息数
        double avgMessagesPerConversation = totalConversations > 0 ? 
                (double) totalMessages / totalConversations : 0;
        
        logger.info("会话统计报告:");
        logger.info("总会话数: {}", totalConversations);
        logger.info("总消息数: {}", totalMessages);
        logger.info("平均每个会话的消息数: {}", String.format("%.2f", avgMessagesPerConversation));
        
        // 这里可以根据需要扩展更多统计信息
    }
}